home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume10 / tgif / patch6.02 < prev    next >
Encoding:
Internet Message Format  |  1990-12-17  |  45.0 KB
  1. Path: uunet!tut.cis.ohio-state.edu!att!news.cs.indiana.edu!julius.cs.uiuc.edu!usc!elroy.jpl.nasa.gov!lll-winken!sun-barr!newstop!exodus!CS.UCLA.EDU
  2. From: william@CS.UCLA.EDU (William Cheng)
  3. Newsgroups: comp.sources.x
  4. Subject: v10i065: tgif, Patch6, Part02/03
  5. Message-ID: <4699@exodus.Eng.Sun.COM>
  6. Date: 18 Dec 90 02:07:15 GMT
  7. References: <csx-10i064:tgif@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1553
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: william@CS.UCLA.EDU (William Cheng)
  13. Posting-number: Volume 10, Issue 65
  14. Archive-name: tgif/patch6.02
  15. Patch-To: Volume 7, Issue 56-76 (original: tgif-1.2)
  16. Patch-To: Volume 8, Issue 46-48 (Patch1: tgif-1.2 => tgif-1.9)
  17. Patch-To: Volume 8, Issue 58-60 (Patch2: tgif-1.9 => tgif-1.12)
  18. Patch-To: Volume 8, Issue 87-89 (Patch3: tgif-1.12 => tgif-1.13)
  19. Patch-To: Volume 8, Issue 94 (Patch4: tgif-1.13 => tgif-1.14)
  20. Patch-To: Volume 8, Issue 95 (Patch5: tgif-1.14 => tgif-1.15)
  21.  
  22. ---------------------------------> cut here <---------------------------------
  23. *** names.c.orig    Sat Oct 27 17:49:07 1990
  24. --- names.c    Sat Oct 27 17:49:08 1990
  25. ***************
  26. *** 6,10 ****
  27.   #ifndef lint
  28.   static char RCSid[] =
  29. !       "@(#)$Header: /n/kona/u/tangram/u/william/X11/TGIF/RCS/names.c,v 1.6 90/07/27 14:39:29 william Exp $";
  30.   #endif
  31.   
  32. --- 6,10 ----
  33.   #ifndef lint
  34.   static char RCSid[] =
  35. !       "@(#)$Header: /n/kona/u/tangram/u/william/X11/TGIF/RCS/names.c,v 1.10 90/10/26 15:40:34 william Exp $";
  36.   #endif
  37.   
  38. ***************
  39. *** 20,23 ****
  40. --- 20,24 ----
  41.   #include "button.e"
  42.   #include "cursor.e"
  43. + #include "file.e"
  44.   #include "font.e"
  45.   #include "mainloop.e"
  46. ***************
  47. *** 33,37 ****
  48. --- 34,50 ----
  49.   #define ROW_HEIGHT (defaultFontHeight+1)
  50.   
  51. + typedef struct _DspList {
  52. +    char            itemstr[MAXPATHLENGTH+1];
  53. +    char            pathstr[MAXPATHLENGTH+1];
  54. +    int            directory;
  55. +    struct _DspList    * next;
  56. + } DspList;
  57. + 
  58. + extern char    * getenv ();
  59. + 
  60.   char    curDomainName[MAXPATHLENGTH];
  61. + char    curDomainPath[MAXPATHLENGTH];
  62. + char    curDir[MAXPATHLENGTH];
  63. + char    curSymDir[MAXPATHLENGTH];
  64.   
  65.   static Window        nameBaseWin;
  66. ***************
  67. *** 55,61 ****
  68.   static GC    revNameGC;
  69.   
  70.   void InitNames ()
  71.   {
  72. !    char        * c_ptr;
  73.      XGCValues    values;
  74.   
  75. --- 68,342 ----
  76.   static GC    revNameGC;
  77.   
  78. + static DspList    * symbolList = NULL;
  79. + static int    numSymbols;
  80. + static DspList    * dirList = NULL;
  81. + static int    numDirEntries;
  82. + 
  83. + static DspList    * topOfSymLinkList = NULL;
  84. + static DspList    * topOfDirLinkList = NULL;
  85. + 
  86. + static
  87. + char * ReadPath (path_str, dir_str)
  88. +    char * path_str, * dir_str;
  89. + {
  90. +    register char        * s1, * s2;
  91. + 
  92. +    s1 = path_str;
  93. +    if (*s1 == '~')
  94. +    {
  95. +       strcpy (dir_str, homeDir);
  96. +       s2 = &dir_str[strlen(dir_str)];
  97. +       s1++;
  98. +    }
  99. +    else
  100. +       s2 = dir_str;
  101. + 
  102. +    for ( ; *s1 != '\0' && *s1 != ':'; s1++)
  103. +       if (*s1 == '\\')
  104. +          strcpy (s1, s1+1);
  105. +       else
  106. +          *s2++ = *s1;
  107. + 
  108. +    *s2 = '\0';
  109. +    if (*s1 == ':') s1++;
  110. +    return (s1);
  111. + }
  112. + 
  113. + void ParseSymPath (path_str)
  114. +    char * path_str;
  115. + {
  116. +    register char        * s, c;
  117. +    register int         i;
  118. +    char                 dir_str[MAXPATHLENGTH];
  119. + 
  120. +    for (i = 0, s = path_str; *s != '\0'; )
  121. +    {
  122. +       s = ReadPath (s, dir_str);
  123. +       if (dir_str != '\0') i++;
  124. +    }
  125. +    symPath = (char * *) calloc (i, sizeof (char *));
  126. +    symPathNumEntries = i;
  127. +    for (i = 0, s = path_str; *s != '\0'; )
  128. +    {
  129. +       s = ReadPath (s, dir_str);
  130. +       if (dir_str != '\0')
  131. +       {
  132. +          symPath[i] = (char *) calloc (MAXPATHLENGTH, sizeof (char));
  133. +          strcpy (symPath[i], dir_str);
  134. +          i++;
  135. +       }
  136. +    }
  137. +    strcpy (curDomainPath, path_str);
  138. + }
  139. + 
  140. + static
  141. + DspList * SymbolListing ()
  142. + {
  143. +    int            i, len, path_index, count = 0, reject;
  144. +    char            path[MAXPATHLENGTH], s[MAXPATHLENGTH];
  145. +    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  146. +    DIR            * dirp;
  147. +    struct direct    * d;
  148. +    struct stat        stat_buf;
  149. + 
  150. +    head_ptr = tail_ptr = NULL;
  151. +    for (path_index = 0; path_index < symPathNumEntries; path_index++)
  152. +    {
  153. +       strcpy (path, symPath[path_index]);
  154. +       if ((dirp = opendir (path)) == NULL)
  155. +          continue;
  156. + 
  157. +       while ((d = readdir (dirp)) != NULL)
  158. +       {
  159. +          len = strlen (d->d_name);
  160. +          if (len > 4 && (strcmp (".sym", &d->d_name[len-4]) == 0))
  161. +             d->d_name[len-4] = '\0';
  162. +          else
  163. +             continue;
  164. + 
  165. +          if (head_ptr == NULL)
  166. +          {
  167. +             head_ptr = tail_ptr = (DspList *) calloc (1, sizeof(DspList));
  168. +             strcpy (head_ptr->itemstr, d->d_name);
  169. +             strcpy (head_ptr->pathstr, path);
  170. +          }
  171. +          else
  172. +          {
  173. +             p1 = NULL;
  174. +             reject = FALSE;
  175. +             for (p = head_ptr; p != NULL; p = p->next)
  176. +             {
  177. +                if (strcmp (d->d_name, p->itemstr) == 0)
  178. +                {
  179. +                   reject = TRUE;
  180. +                   break;
  181. +                }
  182. +                else if (LargerStr (d->d_name, p->itemstr))
  183. +                   p1 = p;
  184. +                else
  185. +                {
  186. +                   dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  187. +                   strcpy (dsp_ptr->itemstr, d->d_name);
  188. +                   strcpy (dsp_ptr->pathstr, path);
  189. +                   break;
  190. +                }
  191. +             }
  192. +             if (reject) continue;
  193. +    
  194. +             dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  195. +             dsp_ptr->next = p;
  196. +             strcpy (dsp_ptr->itemstr, d->d_name);
  197. +             strcpy (dsp_ptr->pathstr, path);
  198. + 
  199. +             if (p == NULL)
  200. +             {  /* dsp_ptr has the largest element */
  201. +                tail_ptr->next = dsp_ptr;
  202. +                tail_ptr = dsp_ptr;
  203. +             }
  204. +             else if (p1 == NULL)
  205. +                head_ptr = dsp_ptr;
  206. +             else
  207. +                p1->next = dsp_ptr;
  208. +          }
  209. +          count++;
  210. +       }
  211. +       closedir (dirp);
  212. +    }
  213. +    numSymbols = count;
  214. +    return (head_ptr);
  215. + }
  216. + 
  217. + static
  218. + void BuildSymbolList ()
  219. + {
  220. +    register int        i;
  221. +    register DspList    * dsp_ptr;
  222. + 
  223. +    if (symbolList != NULL) cfree (symbolList);
  224. + 
  225. +    symbolList = (DspList *) calloc (numSymbols, sizeof (DspList));
  226. +    dsp_ptr = topOfSymLinkList;
  227. +    for (i = 0; i < numSymbols; i++, dsp_ptr = dsp_ptr->next)
  228. +    {
  229. +       strcpy (symbolList[i].itemstr, dsp_ptr->itemstr);
  230. +       strcpy (symbolList[i].pathstr, dsp_ptr->pathstr);
  231. +       symbolList[i].next = &symbolList[i+1];
  232. +       cfree (dsp_ptr);
  233. +    }
  234. +    symbolList[numSymbols].next = NULL;
  235. +    topOfSymLinkList = NULL;
  236. + }
  237. + 
  238. + static
  239. + DspList * DirListing (Path)
  240. +    char    * Path;
  241. + {
  242. +    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  243. +    DIR            * dirp;
  244. +    struct direct    * d;
  245. +    int            len, count = 0;
  246. +    char            path[MAXPATHLENGTH], s[MAXPATHLENGTH];
  247. +    struct stat        stat_buf;
  248. + 
  249. +    if (*Path == '\0')
  250. +    {
  251. +       strcpy (path, "/");
  252. +       if ((dirp = opendir (path)) == NULL) return (NULL);
  253. +    }
  254. +    else
  255. +    {
  256. +       strcpy (path, Path);
  257. +       if ((dirp = opendir (path)) == NULL) return (NULL);
  258. +       strcat (path, "/");
  259. +    }
  260. + 
  261. +    head_ptr = tail_ptr = NULL;
  262. + 
  263. +    while ((d = readdir (dirp)) != NULL)
  264. +    {
  265. +       len = strlen (d->d_name);
  266. +       if (len > 4 && (strcmp (".obj", &d->d_name[len-4]) == 0))
  267. +       {
  268. +          d->d_name[len-4] = '\0';
  269. +          dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  270. +          dsp_ptr->directory = FALSE;
  271. +          strcpy (dsp_ptr->itemstr, d->d_name);
  272. +       }
  273. +       else if (strcmp (d->d_name, ".") == 0)
  274. +          continue;
  275. +       else
  276. +       {
  277. +          strcpy (s, path);
  278. +          strcat (s, d->d_name);
  279. +          stat (s, &stat_buf);
  280. +          if (stat_buf.st_mode & S_IFDIR)
  281. +          {
  282. +             dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  283. +             dsp_ptr->directory = TRUE;
  284. +             strcat (d->d_name, "/");
  285. +             strcpy (dsp_ptr->itemstr, d->d_name);
  286. +          }
  287. +          else
  288. +             continue;
  289. +       }
  290. +       if (head_ptr == NULL)
  291. +          head_ptr = tail_ptr = dsp_ptr;
  292. +       else
  293. +       {
  294. +          p1 = NULL;
  295. +          for (p = head_ptr; p != NULL; p = p->next)
  296. +             if (LargerStr (d->d_name, p->itemstr))
  297. +                p1 = p;
  298. +             else
  299. +                break;
  300. + 
  301. +          dsp_ptr->next = p;
  302. +          if (p == NULL)
  303. +          {  /* dsp_ptr has the largest element */
  304. +             tail_ptr->next = dsp_ptr;
  305. +             tail_ptr = dsp_ptr;
  306. +          }
  307. +          else if (p1 == NULL)
  308. +             head_ptr = dsp_ptr;
  309. +          else
  310. +             p1->next = dsp_ptr;
  311. +       }
  312. +       count++;
  313. +    }
  314. + 
  315. +    closedir (dirp);
  316. +    numDirEntries = count;
  317. +    return (head_ptr);
  318. + }
  319. + 
  320. + static
  321. + void BuildDirList ()
  322. + {
  323. +    register int        i;
  324. +    register DspList    * dsp_ptr;
  325. + 
  326. +    if (topOfDirLinkList != NULL)
  327. +    {
  328. +       if (dirList != NULL) cfree (dirList);
  329. + 
  330. +       dirList = (DspList *) calloc (numDirEntries, sizeof (DspList));
  331. +       dsp_ptr = topOfDirLinkList;
  332. +       for (i = 0; i < numDirEntries; i++, dsp_ptr = dsp_ptr->next)
  333. +       {
  334. +          strcpy (dirList[i].itemstr, dsp_ptr->itemstr);
  335. +          strcpy (dirList[i].pathstr, dsp_ptr->pathstr);
  336. +          dirList[i].directory = dsp_ptr->directory;
  337. +          dirList[i].next = &dirList[i+1];
  338. +          cfree (dsp_ptr);
  339. +       }
  340. +       dirList[numDirEntries].next = NULL;
  341. +       topOfDirLinkList = NULL;
  342. +    }
  343. + }
  344. + 
  345.   void InitNames ()
  346.   {
  347. !    int        default_found = FALSE;
  348. !    char        * c_ptr, domain_str[20], sym_path[80];
  349.      XGCValues    values;
  350.   
  351. ***************
  352. *** 79,82 ****
  353. --- 360,366 ----
  354.   
  355.      *curDomainName = '\0';
  356. +    *curDomainPath = '\0';
  357. +    *curSymDir = '\0';
  358. +    strcpy (curDir, bootDir);
  359.   
  360.      if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, "DoubleClickInterval")) !=
  361. ***************
  362. *** 85,90 ****
  363. --- 369,407 ----
  364.      else
  365.         doubleClickInterval = 300;
  366. + 
  367. +    if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, "DefaultDomain")) != NULL)
  368. +    {
  369. +       sprintf (domain_str, "Domain%s", c_ptr);
  370. +       if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, domain_str)) != NULL)
  371. +       {
  372. +          if (*c_ptr != '\0')
  373. +          {
  374. +             strcpy (curDomainName, c_ptr);
  375. +             sprintf (sym_path, "TGIF_%s", c_ptr);
  376. +             default_found = TRUE;
  377. +          }
  378. +       }
  379. +    }
  380. + 
  381. +    if (!default_found || (c_ptr = getenv (sym_path)) == NULL)
  382. +       ParseSymPath (".");
  383. +    else
  384. +       if (strlen (c_ptr) >= MAXPATHLENGTH-1)
  385. +          ParseSymPath (".");
  386. +       else 
  387. +          ParseSymPath (c_ptr);
  388. +    if ((topOfSymLinkList = SymbolListing ()) != NULL) BuildSymbolList ();
  389.   }
  390.   
  391. + void UpdateDirInfo ()
  392. + {
  393. +    if ((topOfDirLinkList = DirListing (curDir)) != NULL) BuildDirList ();
  394. + }
  395. + 
  396. + void UpdateSymInfo ()
  397. + {
  398. +    if ((topOfSymLinkList = SymbolListing ()) != NULL) BuildSymbolList ();
  399. + }
  400. + 
  401.   void CleanUpNames ()
  402.   {
  403. ***************
  404. *** 91,94 ****
  405. --- 408,414 ----
  406.      XFreeGC (mainDisplay, nameGC);
  407.      XFreeGC (mainDisplay, revNameGC);
  408. + 
  409. +    if (symbolList != NULL) cfree (symbolList);
  410. +    if (dirList != NULL) cfree (dirList);
  411.   }
  412.   
  413. ***************
  414. *** 145,149 ****
  415.      register int    i;
  416.      int        top, len, end, pixel;
  417. -    DspItem    * diptr;
  418.      XGCValues    values;
  419.   
  420. --- 465,468 ----
  421. ***************
  422. *** 181,188 ****
  423.   
  424.   static
  425. ! void RedrawNameBaseWindow (Str, str_start, button_start, W, H)
  426. !    char    * Str;
  427. !    int    str_start, button_start;
  428.   {
  429.      int    top = defaultFontAsc+2;
  430.   
  431. --- 500,536 ----
  432.   
  433.   static
  434. ! void RedrawNamePath (Path, X, Y)
  435. !    char    * Path;
  436. !    int    X, Y;
  437.   {
  438. +    int    len = strlen (Path), cursor_x, cursor_y;
  439. +    char    * c_ptr;
  440. + 
  441. +    cursor_y = Y-defaultFontAsc;
  442. + 
  443. +    XClearArea (mainDisplay, nameBaseWin, X, Y-defaultFontAsc,
  444. +          ITEM_LEN*defaultFontWidth+4, defaultFontHeight+4, False);
  445. +    XDrawRectangle (mainDisplay, nameBaseWin, nameGC, X, cursor_y-2,
  446. +          ITEM_LEN*defaultFontWidth+8, defaultFontHeight+4);
  447. + 
  448. +    if (len > ITEM_LEN)
  449. +    {
  450. +       c_ptr = &(Path[len-ITEM_LEN]);
  451. +       len = ITEM_LEN;
  452. +    }
  453. +    else
  454. +       c_ptr = Path;
  455. + 
  456. +    cursor_x = X+2+len*defaultFontWidth;
  457. +    XDrawString (mainDisplay, nameBaseWin, nameGC, X+2, Y, c_ptr, len);
  458. +    XDrawLine (mainDisplay, nameBaseWin, nameGC, cursor_x,
  459. +          cursor_y, cursor_x, cursor_y+defaultFontHeight);
  460. + }
  461. + 
  462. + static
  463. + void RedrawNameBaseWindow (Str, Path, str_start, path_start, button_start, W, H)
  464. +    char    * Str, * Path;
  465. +    int    str_start, path_start, button_start, W, H;
  466. + {
  467.      int    top = defaultFontAsc+2;
  468.   
  469. ***************
  470. *** 190,199 ****
  471.      XDrawString (mainDisplay, nameBaseWin, nameGC, str_start,
  472.            ROW_HEIGHT+top, Str, strlen(Str));
  473.   
  474. !    buttonBBox[0].lty = buttonBBox[1].lty = (ITEM_DSPED+4) * ROW_HEIGHT;
  475.      buttonBBox[0].ltx = button_start;
  476. !    DisplayButton (nameBaseWin, "OK", 8, &buttonBBox[0], BUTTON_NORMAL);
  477.      buttonBBox[1].ltx = buttonBBox[CONFIRM_YES].rbx + 1 + defaultFontWidth;
  478. !    DisplayButton (nameBaseWin, "CANCEL", 8, &buttonBBox[1],
  479.            BUTTON_NORMAL);
  480.   }
  481. --- 538,548 ----
  482.      XDrawString (mainDisplay, nameBaseWin, nameGC, str_start,
  483.            ROW_HEIGHT+top, Str, strlen(Str));
  484. +    RedrawNamePath (Path, path_start, 3*ROW_HEIGHT+top);
  485.   
  486. !    buttonBBox[0].lty = buttonBBox[1].lty = (ITEM_DSPED+6) * ROW_HEIGHT;
  487.      buttonBBox[0].ltx = button_start;
  488. !    DisplayButton (nameBaseWin, "OK", 8, &(buttonBBox[0]), BUTTON_NORMAL);
  489.      buttonBBox[1].ltx = buttonBBox[CONFIRM_YES].rbx + 1 + defaultFontWidth;
  490. !    DisplayButton (nameBaseWin, "CANCEL", 8, &(buttonBBox[1]),
  491.            BUTTON_NORMAL);
  492.   }
  493. ***************
  494. *** 213,221 ****
  495.         dsp_ptr[i] = c_ptr;
  496.         len = strlen (DLPtr->itemstr);
  497. !       for (j = len; j >= 0 && DLPtr->itemstr[j] != '/'; j--) ;
  498. !       if (j >= 0)
  499. !          strcpy (c_ptr, (&DLPtr->itemstr[j])+1);
  500.         else
  501.            strcpy (c_ptr, DLPtr->itemstr);
  502.         c_ptr += MAXPATHLENGTH;
  503.      }
  504. --- 562,576 ----
  505.         dsp_ptr[i] = c_ptr;
  506.         len = strlen (DLPtr->itemstr);
  507. !       if (!DLPtr->directory)
  508. !       {
  509. !          for (j = len; j >= 0 && DLPtr->itemstr[j] != '/'; j--) ;
  510. !          if (j >= 0)
  511. !             strcpy (c_ptr, (&(DLPtr->itemstr[j]))+1);
  512. !          else
  513. !             strcpy (c_ptr, DLPtr->itemstr);
  514. !       }
  515.         else
  516.            strcpy (c_ptr, DLPtr->itemstr);
  517. + 
  518.         c_ptr += MAXPATHLENGTH;
  519.      }
  520. ***************
  521. *** 343,362 ****
  522.   
  523.   static
  524. ! int Names (Str)
  525. !    char    * Str;
  526.   {
  527. !    int        x, y, pixel, button_widths, str_width, graph_width, w, h;
  528. !    int        str_start, button_start, graph_start, index;
  529. !    int        dsp_w, dsp_h;
  530. !    XEvent    input, ev;
  531. !    int        i, len, looping = TRUE, grabbed = FALSE;
  532. !    char        buf[80];
  533. !    XKeyEvent    * key_ev;
  534. !    XButtonEvent    * button_ev;
  535. !    KeySym    key_sym;
  536.      XComposeStatus    c_stat;
  537.      XSetWindowAttributes    win_attrs;
  538. !    int        win_x, win_y, win_w, win_h, win_d, win_brdr_w;
  539. !    Window    root_win;
  540.   
  541.      dsp_w = DisplayWidth (mainDisplay, mainScreen);
  542. --- 698,729 ----
  543.   
  544.   static
  545. ! int LargerStr (S1, S2)
  546. !    register char    * S1, * S2;
  547. !    /* returns TRUE if S1 > S2 */
  548.   {
  549. !    while (*S1 == *S2 && *S1 != '\0' && *S2 != '\0') { S1++; S2++; }
  550. ! 
  551. !    return (*S1 > *S2);
  552. ! }
  553. ! 
  554. ! static
  555. ! int DirNames (TopStr, SelStr)
  556. !    char    * TopStr, * SelStr;
  557. ! {
  558. !    int            pixel, button_widths, str_width, graph_width;
  559. !    int            str_start, button_start, graph_start, index;
  560. !    int            dsp_w, dsp_h, x, y, w, h, i, len, exposure = 0;
  561. !    XEvent        input, ev;
  562. !    int            looping = TRUE, changing, grabbed = FALSE, name_index;
  563. !    char            buf[80], name[MAXPATHLENGTH], full_name[MAXPATHLENGTH];
  564. !    char            dir_name[MAXPATHLENGTH], sel_str[MAXPATHLENGTH];
  565. !    XKeyEvent        * key_ev;
  566. !    XButtonEvent        * button_ev;
  567. !    KeySym        key_sym;
  568.      XComposeStatus    c_stat;
  569.      XSetWindowAttributes    win_attrs;
  570. !    int            win_x, win_y, win_w, win_h, win_d, win_brdr_w;
  571. !    Window        root_win;
  572. !    DspList        * dsp_ptr, * head_dsp_ptr;
  573.   
  574.      dsp_w = DisplayWidth (mainDisplay, mainScreen);
  575. ***************
  576. *** 365,369 ****
  577.      button_widths = ButtonWidth("OK", 8) + ButtonWidth("CANCEL", 8) +
  578.            defaultFontWidth;
  579. !    str_width = defaultFontWidth * strlen (Str);
  580.      graph_width = nameDspWinW + scrollBarW + 2 * brdrW;
  581.   
  582. --- 732,736 ----
  583.      button_widths = ButtonWidth("OK", 8) + ButtonWidth("CANCEL", 8) +
  584.            defaultFontWidth;
  585. !    str_width = defaultFontWidth * strlen (TopStr);
  586.      graph_width = nameDspWinW + scrollBarW + 2 * brdrW;
  587.   
  588. ***************
  589. *** 381,385 ****
  590.      }
  591.      button_start = (w - button_widths) / 2;
  592. !    h = (6 + ITEM_DSPED) * ROW_HEIGHT;
  593.   
  594.      win_x = (w > dsp_w) ? 0 : (dsp_w - w)/2;
  595. --- 748,752 ----
  596.      }
  597.      button_start = (w - button_widths) / 2;
  598. !    h = (8 + ITEM_DSPED) * ROW_HEIGHT;
  599.   
  600.      win_x = (w > dsp_w) ? 0 : (dsp_w - w)/2;
  601. ***************
  602. *** 393,397 ****
  603.   
  604.      if ((nameDspWin = XCreateSimpleWindow (mainDisplay, nameBaseWin, graph_start,
  605. !          3*ROW_HEIGHT, nameDspW, nameDspH, brdrW, myBorderPixel,
  606.            myBgPixel)) == 0)
  607.      { printf ("Could not create desired popup window!\n"); exit (-1); }
  608. --- 760,764 ----
  609.   
  610.      if ((nameDspWin = XCreateSimpleWindow (mainDisplay, nameBaseWin, graph_start,
  611. !          5*ROW_HEIGHT, nameDspW, nameDspH, brdrW, myBorderPixel,
  612.            myBgPixel)) == 0)
  613.      { printf ("Could not create desired popup window!\n"); exit (-1); }
  614. ***************
  615. *** 398,402 ****
  616.   
  617.      if ((nameScrollWin = XCreateSimpleWindow (mainDisplay, nameBaseWin,
  618. !          graph_start+nameDspWinW, 3*ROW_HEIGHT, scrollBarW, nameDspH,
  619.            brdrW, myBorderPixel, myBgPixel)) == 0)
  620.      { printf ("Could not create desired popup scroll window!\n"); exit (-1); }
  621. --- 765,769 ----
  622.   
  623.      if ((nameScrollWin = XCreateSimpleWindow (mainDisplay, nameBaseWin,
  624. !          graph_start+nameDspWinW, 5*ROW_HEIGHT, scrollBarW, nameDspH,
  625.            brdrW, myBorderPixel, myBgPixel)) == 0)
  626.      { printf ("Could not create desired popup scroll window!\n"); exit (-1); }
  627. ***************
  628. *** 419,425 ****
  629. --- 786,1122 ----
  630.            KeyPressMask | ButtonPressMask | ExposureMask);
  631.   
  632. +    strcpy (dir_name, curDir);
  633. + 
  634.      justClicked = FALSE;
  635.      while (looping)
  636.      {
  637. +       nameEntries = numDirEntries;
  638. +       if (topOfDirLinkList == NULL)
  639. +          nameDspPtr = MakeNameDspItemArray (nameEntries, dirList);
  640. +       else
  641. +          nameDspPtr = MakeNameDspItemArray (nameEntries, topOfDirLinkList);
  642. +       nameFirst = 0;
  643. +       nameMarked = 0;
  644. + 
  645. +       strcpy (full_name, dir_name);
  646. +       strcat (full_name, "/");
  647. +       name[0] = '\0';
  648. +       name_index = 0;
  649. + 
  650. +       if (exposure >= 3)
  651. +       {
  652. +          XClearWindow (mainDisplay, nameBaseWin);
  653. +          XClearWindow (mainDisplay, nameDspWin);
  654. +          XClearWindow (mainDisplay, nameScrollWin);
  655. +          RedrawNameBaseWindow (TopStr, full_name, str_start, graph_start,
  656. +                button_start, w, h);
  657. +          RedrawNameScrollWin ();
  658. +          RedrawDspWindow ();
  659. +       }
  660. + 
  661. +       changing = TRUE;
  662. +       while (changing)
  663. +       {
  664. +          XNextEvent (mainDisplay, &input);
  665. +          if (input.type == Expose)
  666. +          {
  667. +             if (input.xany.window == nameBaseWin)
  668. +             {
  669. +                RedrawNameBaseWindow (TopStr, full_name, str_start, graph_start,
  670. +                      button_start, w, h);
  671. +                exposure++;
  672. +             }
  673. +             else if (input.xany.window == nameScrollWin)
  674. +             {
  675. +                RedrawNameScrollWin ();
  676. +                exposure++;
  677. +             }
  678. +             else if (input.xany.window == nameDspWin)
  679. +             {
  680. +                RedrawDspWindow ();
  681. +                exposure++;
  682. +             }
  683. + 
  684. + /*          if (!grabbed)
  685. +             {
  686. +                XGrabKeyboard (mainDisplay, nameBaseWin, False,
  687. +                      GrabModeAsync, GrabModeAsync, CurrentTime);
  688. +                grabbed = TRUE;
  689. +             } */
  690. + 
  691. +             continue;
  692. +          }
  693. +          else if (input.type == KeyPress)
  694. +          {
  695. +             key_ev = &(input.xkey);
  696. +             XLookupString (key_ev, buf, 80, &key_sym, &c_stat);
  697. + 
  698. +             if ((buf[0]=='\r' && (key_sym & 0xff)=='\r') ||
  699. +                 (buf[0]=='\n' && (key_sym & 0xff)=='\n'))
  700. +             {
  701. +                changing = FALSE;
  702. +                index = nameMarked;
  703. +             }
  704. +             else if (buf[0]=='\033' && (key_sym & 0xff)=='\033')
  705. +             {
  706. +                looping = FALSE;
  707. +                changing = FALSE;
  708. +                index = INVALID;
  709. +             }
  710. +             else if (buf[0] == '\b' || buf[0] == '\177')
  711. +             {
  712. +                if (name_index != 0)
  713. +                {
  714. +                   name[--name_index] = '\0';
  715. +                   strcpy (full_name, dir_name);
  716. +                   strcat (full_name, "/");
  717. +                   strcat (full_name, name);
  718. +                   for (i = 0; i < nameEntries; i++)
  719. +                      if (strncmp (nameDspPtr[i], name, name_index) == 0)
  720. +                         break;
  721. + 
  722. +                   if (i < nameEntries)
  723. +                   {
  724. +                      if (i < nameFirst)
  725. +                         nameFirst = i;
  726. +                      else if (i >= nameFirst+ITEM_DSPED)
  727. +                      {
  728. +                         if (i < nameEntries-ITEM_DSPED)
  729. +                            nameFirst = i;
  730. +                         else
  731. +                            nameFirst = nameEntries-ITEM_DSPED;
  732. +                      }
  733. +                      nameMarked = i;
  734. +                      RedrawNamePath (full_name, graph_start,
  735. +                            3*ROW_HEIGHT+defaultFontAsc+2);
  736. +                      RedrawNameScrollWin ();
  737. +                      RedrawDspWindow ();
  738. +                   }
  739. +                }
  740. +             }
  741. +             else if (key_sym>='\040' && key_sym<='\177')
  742. +             {
  743. +                if (buf[0] == '$')
  744. +                {
  745. +                   i = (nameEntries == 0) ? 0 : nameEntries-1;
  746. +                   strcpy (name, nameDspPtr[i]);
  747. +                }
  748. +                else
  749. +                {
  750. +                   name[name_index++] = buf[0];
  751. +                   name[name_index] = '\0';
  752. +                   for (i = 0; i < nameEntries; i++)
  753. +                      if (strncmp (nameDspPtr[i], name, name_index) == 0)
  754. +                         break;
  755. +                }
  756. + 
  757. +                if (i < nameEntries)
  758. +                {
  759. +                   if (i < nameFirst)
  760. +                      nameFirst = i;
  761. +                   else if (i >= nameFirst+ITEM_DSPED)
  762. +                   {
  763. +                      if (i < nameEntries-ITEM_DSPED)
  764. +                         nameFirst = i;
  765. +                      else
  766. +                         nameFirst = nameEntries-ITEM_DSPED;
  767. +                   }
  768. +                   nameMarked = i;
  769. + 
  770. +                   strcpy (full_name, dir_name);
  771. +                   strcat (full_name, "/");
  772. +                   strcat (full_name, name);
  773. +                   RedrawNamePath (full_name, graph_start,
  774. +                         3*ROW_HEIGHT+defaultFontAsc+2);
  775. +                   RedrawNameScrollWin ();
  776. +                   RedrawDspWindow ();
  777. +                }
  778. +                else
  779. +                   name[--name_index] = '\0';
  780. +             }
  781. +          }
  782. +          else if (input.type == ButtonPress)
  783. +          {
  784. +             button_ev = &(input.xbutton);
  785. +             if (button_ev->window == nameBaseWin)
  786. +             {
  787. +                if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[0]))
  788. +                {
  789. +                   changing = FALSE;
  790. +                   index = nameMarked;
  791. +                }
  792. +                else if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[1]))
  793. +                {
  794. +                   looping = FALSE;
  795. +                   changing = FALSE;
  796. +                   index = INVALID;
  797. +                }
  798. +             }
  799. +             else if (button_ev->window == nameScrollWin)
  800. +                NameScrollHandler (button_ev);
  801. +             else if (button_ev->window == nameDspWin)
  802. +             {
  803. +                if (NameDspHandler (button_ev) != INVALID)
  804. +                {
  805. +                   changing = FALSE;
  806. +                   index = nameMarked;
  807. +                }
  808. +                else if (nameMarked != INVALID)
  809. +                {
  810. +                   strcpy (name, nameDspPtr[nameMarked]);
  811. +                   strcpy (full_name, dir_name);
  812. +                   strcat (full_name, "/");
  813. +                   strcat (full_name, name);
  814. +                   RedrawNamePath (full_name, graph_start,
  815. +                         3*ROW_HEIGHT+defaultFontAsc+2);
  816. +                }
  817. +             }
  818. +          }
  819. +       }
  820. + 
  821. +       if (index != INVALID) strcpy (sel_str, nameDspPtr[index]);
  822. + 
  823. +       cfree (*nameDspPtr);
  824. +       cfree (nameDspPtr);
  825. + 
  826. +       if (index == INVALID) break;
  827. + 
  828. +       if (sel_str[strlen(sel_str)-1] == '/')
  829. +       {
  830. +          sel_str[strlen(sel_str)-1] = '\0';
  831. +          if (strcmp (sel_str, "..") == 0)
  832. +          {
  833. +             for (i = strlen(dir_name)-1; i>=0 && dir_name[i]!='/'; i--) ;
  834. +             if (i < 0)
  835. +                dir_name[0] = '\0';
  836. +             else
  837. +                dir_name[i] = '\0';
  838. +          }
  839. +          else
  840. +          {
  841. +             strcat (dir_name, "/");
  842. +             strcat (dir_name, sel_str);
  843. +          }
  844. + 
  845. +          dsp_ptr = topOfDirLinkList;
  846. +          for ( ; dsp_ptr != NULL; dsp_ptr = dsp_ptr->next) cfree (dsp_ptr);
  847. +          topOfDirLinkList = NULL;
  848. + 
  849. +          Msg ("Generating list of file names, please wait ...");
  850. +          if ((topOfDirLinkList = DirListing (dir_name)) == NULL)
  851. +          {
  852. +             *sel_str = '\0';
  853. +             break;
  854. +          }
  855. +          Msg ("");
  856. +       }
  857. +       else
  858. +          break;
  859. +    }
  860. +    if (grabbed) XUngrabKeyboard (mainDisplay, CurrentTime);
  861. + 
  862. +    strcpy (SelStr, dir_name);
  863. +    strcat (SelStr, "/");
  864. +    strcat (SelStr, sel_str);
  865. + 
  866. +    if (index == INVALID)
  867. +       DisplayButton (nameBaseWin, okCancelStr[1], 8, &buttonBBox[1],
  868. +             BUTTON_INVERT);
  869. +    else
  870. +       DisplayButton (nameBaseWin, okCancelStr[0], 8, &buttonBBox[0],
  871. +             BUTTON_INVERT);
  872. + 
  873. +    XDestroyWindow (mainDisplay, nameBaseWin);
  874. +    XSync (mainDisplay, FALSE);
  875. +    while (XCheckMaskEvent (mainDisplay, ExposureMask, &input)) ;
  876. +    return (index);
  877. + }
  878. + 
  879. + static
  880. + int ChooseAName (TopStr, SelStr)
  881. +    char    * TopStr, * SelStr;
  882. + {
  883. +    int            button_widths, str_width, graph_width;
  884. +    int            str_start, button_start, graph_start, index;
  885. +    int            dsp_w, dsp_h, x, y, w, h, i, len;
  886. +    XEvent        input, ev;
  887. +    int            changing = TRUE, grabbed = FALSE, name_index;
  888. +    char            buf[80], name[MAXPATHLENGTH];
  889. +    XKeyEvent        * key_ev;
  890. +    XButtonEvent        * button_ev;
  891. +    KeySym        key_sym;
  892. +    XComposeStatus    c_stat;
  893. +    XSetWindowAttributes    win_attrs;
  894. +    int            win_x, win_y, win_w, win_h, win_d, win_brdr_w;
  895. + 
  896. +    dsp_w = DisplayWidth (mainDisplay, mainScreen);
  897. +    dsp_h = DisplayHeight (mainDisplay, mainScreen);
  898. + 
  899. +    button_widths = ButtonWidth("OK", 8) + ButtonWidth("CANCEL", 8) +
  900. +          defaultFontWidth;
  901. +    str_width = defaultFontWidth * strlen (TopStr);
  902. +    graph_width = nameDspWinW + scrollBarW + 2 * brdrW;
  903. + 
  904. +    if (str_width > graph_width)
  905. +    {
  906. +       w = str_width + 4 * defaultFontWidth;
  907. +       str_start = 2 * defaultFontWidth;
  908. +       graph_start = (w - graph_width) / 2;
  909. +    }
  910. +    else
  911. +    {
  912. +       w = graph_width + 4 * defaultFontWidth;
  913. +       str_start = (w - str_width) / 2;
  914. +       graph_start = 2 * defaultFontWidth;
  915. +    }
  916. +    button_start = (w - button_widths) / 2;
  917. +    h = (8 + ITEM_DSPED) * ROW_HEIGHT;
  918. + 
  919. +    win_x = (w > dsp_w) ? 0 : (dsp_w - w)/2;
  920. +    win_y = (h > dsp_h) ? 0 : (dsp_h - h)/3;
  921. + 
  922. +    if ((nameBaseWin = XCreateSimpleWindow (mainDisplay, rootWindow,
  923. +          win_x, win_y, w, h, brdrW, myBorderPixel, myBgPixel)) == 0)
  924. +    { printf ("Could not create desired popup window!\n"); exit (-1); }
  925. + 
  926. +    XDefineCursor (mainDisplay, nameBaseWin, defaultCursor);
  927. + 
  928. +    if ((nameDspWin = XCreateSimpleWindow (mainDisplay, nameBaseWin, graph_start,
  929. +          5*ROW_HEIGHT, nameDspW, nameDspH, brdrW, myBorderPixel,
  930. +          myBgPixel)) == 0)
  931. +    { printf ("Could not create desired popup window!\n"); exit (-1); }
  932. + 
  933. +    if ((nameScrollWin = XCreateSimpleWindow (mainDisplay, nameBaseWin,
  934. +          graph_start+nameDspWinW, 5*ROW_HEIGHT, scrollBarW, nameDspH,
  935. +          brdrW, myBorderPixel, myBgPixel)) == 0)
  936. +    { printf ("Could not create desired popup scroll window!\n"); exit (-1); }
  937. + 
  938. +    win_attrs.save_under = True;
  939. +    XChangeWindowAttributes (mainDisplay, nameBaseWin, CWSaveUnder, &win_attrs);
  940. + 
  941. +    XSetTransientForHint (mainDisplay, nameBaseWin, mainWindow);
  942. + 
  943. +    XMapWindow (mainDisplay, nameBaseWin);
  944. +    XSelectInput (mainDisplay, nameBaseWin,
  945. +          KeyPressMask | ButtonPressMask | ExposureMask);
  946. + 
  947. +    XMapWindow (mainDisplay, nameDspWin);
  948. +    XSelectInput (mainDisplay, nameDspWin,
  949. +          KeyPressMask | ButtonPressMask | ExposureMask);
  950. + 
  951. +    XMapWindow (mainDisplay, nameScrollWin);
  952. +    XSelectInput (mainDisplay, nameScrollWin,
  953. +          KeyPressMask | ButtonPressMask | ExposureMask);
  954. + 
  955. +    justClicked = FALSE;
  956. + 
  957. +    Msg ("");
  958. + 
  959. +    name[0] = '\0';
  960. +    name_index = 0;
  961. +    nameMarked = INVALID;
  962. + 
  963. +    while (changing)
  964. +    {
  965.         XNextEvent (mainDisplay, &input);
  966.         if (input.type == Expose)
  967. ***************
  968. *** 426,430 ****
  969.         {
  970.            if (input.xany.window == nameBaseWin)
  971. !             RedrawNameBaseWindow (Str, str_start, button_start, w, h);
  972.            else if (input.xany.window == nameScrollWin)
  973.               RedrawNameScrollWin ();
  974. --- 1123,1128 ----
  975.         {
  976.            if (input.xany.window == nameBaseWin)
  977. !             RedrawNameBaseWindow (TopStr, name, str_start, graph_start,
  978. !                   button_start, w, h);
  979.            else if (input.xany.window == nameScrollWin)
  980.               RedrawNameScrollWin ();
  981. ***************
  982. *** 432,436 ****
  983.               RedrawDspWindow ();
  984.   
  985. !          if (!grabbed)
  986.            {
  987.               XGrabKeyboard (mainDisplay, nameBaseWin, False,
  988. --- 1130,1134 ----
  989.               RedrawDspWindow ();
  990.   
  991. ! /*       if (!grabbed)
  992.            {
  993.               XGrabKeyboard (mainDisplay, nameBaseWin, False,
  994. ***************
  995. *** 437,441 ****
  996.                     GrabModeAsync, GrabModeAsync, CurrentTime);
  997.               grabbed = TRUE;
  998. !          }
  999.   
  1000.            continue;
  1001. --- 1135,1139 ----
  1002.                     GrabModeAsync, GrabModeAsync, CurrentTime);
  1003.               grabbed = TRUE;
  1004. !          } */
  1005.   
  1006.            continue;
  1007. ***************
  1008. *** 446,466 ****
  1009.            XLookupString (key_ev, buf, 80, &key_sym, &c_stat);
  1010.   
  1011. !          if (buf[0] == '\r' || buf[0] == '\n')
  1012.            {
  1013. !             looping = FALSE;
  1014.               index = nameMarked;
  1015.            }
  1016. !          else if (buf[0] == '\033')
  1017.            {
  1018. !             looping = FALSE;
  1019.               index = INVALID;
  1020.            }
  1021.            else if (key_sym>='\040' && key_sym<='\177')
  1022.            {
  1023.               if (buf[0] == '$')
  1024.                  i = (nameEntries == 0) ? 0 : nameEntries-1;
  1025.               else
  1026.                  for (i = 0; i < nameEntries; i++)
  1027. !                   if (*nameDspPtr[i] == buf[0]) break;
  1028.               if (i < nameEntries)
  1029.               {
  1030. --- 1144,1202 ----
  1031.            XLookupString (key_ev, buf, 80, &key_sym, &c_stat);
  1032.   
  1033. !          if ((buf[0]=='\r' && (key_sym & 0xff)=='\r') ||
  1034. !              (buf[0]=='\n' && (key_sym & 0xff)=='\n'))
  1035.            {
  1036. !             changing = FALSE;
  1037.               index = nameMarked;
  1038.            }
  1039. !          else if (buf[0]=='\033' && (key_sym & 0xff)=='\033')
  1040.            {
  1041. !             changing = FALSE;
  1042.               index = INVALID;
  1043.            }
  1044. +          else if (buf[0] == '\b' || buf[0] == '\177')
  1045. +          {
  1046. +             if (name_index != 0)
  1047. +             {
  1048. +                name[--name_index] = '\0';
  1049. +                for (i = 0; i < nameEntries; i++)
  1050. +                   if (strncmp (nameDspPtr[i], name, name_index) == 0)
  1051. +                      break;
  1052. + 
  1053. +                if (i < nameEntries)
  1054. +                {
  1055. +                   if (i < nameFirst)
  1056. +                      nameFirst = i;
  1057. +                   else if (i >= nameFirst+ITEM_DSPED)
  1058. +                   {
  1059. +                      if (i < nameEntries-ITEM_DSPED)
  1060. +                         nameFirst = i;
  1061. +                      else
  1062. +                         nameFirst = nameEntries-ITEM_DSPED;
  1063. +                   }
  1064. +                   nameMarked = i;
  1065. +                   RedrawNamePath (name, graph_start,
  1066. +                         3*ROW_HEIGHT+defaultFontAsc+2);
  1067. +                   RedrawNameScrollWin ();
  1068. +                   RedrawDspWindow ();
  1069. +                }
  1070. +             }
  1071. +          }
  1072.            else if (key_sym>='\040' && key_sym<='\177')
  1073.            {
  1074.               if (buf[0] == '$')
  1075. +             {
  1076.                  i = (nameEntries == 0) ? 0 : nameEntries-1;
  1077. +                strcpy (name, nameDspPtr[i]);
  1078. +             }
  1079.               else
  1080. +             {
  1081. +                name[name_index++] = buf[0];
  1082. +                name[name_index] = '\0';
  1083.                  for (i = 0; i < nameEntries; i++)
  1084. !                   if (strncmp (nameDspPtr[i], name, name_index) == 0)
  1085. !                      break;
  1086. !             }
  1087. ! 
  1088.               if (i < nameEntries)
  1089.               {
  1090. ***************
  1091. *** 475,481 ****
  1092. --- 1211,1222 ----
  1093.                  }
  1094.                  nameMarked = i;
  1095. + 
  1096. +                RedrawNamePath (name, graph_start,
  1097. +                      3*ROW_HEIGHT+defaultFontAsc+2);
  1098.                  RedrawNameScrollWin ();
  1099.                  RedrawDspWindow ();
  1100.               }
  1101. +             else
  1102. +                name[--name_index] = '\0';
  1103.            }
  1104.         }
  1105. ***************
  1106. *** 487,491 ****
  1107.               if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[0]))
  1108.               {
  1109. !                looping = FALSE;
  1110.                  index = nameMarked;
  1111.               }
  1112. --- 1228,1232 ----
  1113.               if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[0]))
  1114.               {
  1115. !                changing = FALSE;
  1116.                  index = nameMarked;
  1117.               }
  1118. ***************
  1119. *** 492,496 ****
  1120.               else if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[1]))
  1121.               {
  1122. !                looping = FALSE;
  1123.                  index = INVALID;
  1124.               }
  1125. --- 1233,1237 ----
  1126.               else if (PointInBBox (button_ev->x, button_ev->y, buttonBBox[1]))
  1127.               {
  1128. !                changing = FALSE;
  1129.                  index = INVALID;
  1130.               }
  1131. ***************
  1132. *** 502,508 ****
  1133.               if (NameDspHandler (button_ev) != INVALID)
  1134.               {
  1135. !                looping = FALSE;
  1136.                  index = nameMarked;
  1137.               }
  1138.            }
  1139.         }
  1140. --- 1243,1256 ----
  1141.               if (NameDspHandler (button_ev) != INVALID)
  1142.               {
  1143. !                changing = FALSE;
  1144.                  index = nameMarked;
  1145.               }
  1146. +             else if (nameMarked != INVALID)
  1147. +             {
  1148. +                strcpy (name, nameDspPtr[nameMarked]);
  1149. +                name_index = strlen (name);
  1150. +                RedrawNamePath (name, graph_start,
  1151. +                      3*ROW_HEIGHT+defaultFontAsc+2);
  1152. +             }
  1153.            }
  1154.         }
  1155. ***************
  1156. *** 514,519 ****
  1157. --- 1262,1270 ----
  1158.               BUTTON_INVERT);
  1159.      else
  1160. +    {
  1161. +       strcpy (SelStr, nameDspPtr[index]);
  1162.         DisplayButton (nameBaseWin, okCancelStr[0], 8, &buttonBBox[0],
  1163.               BUTTON_INVERT);
  1164. +    }
  1165.   
  1166.      XDestroyWindow (mainDisplay, nameBaseWin);
  1167. ***************
  1168. *** 523,698 ****
  1169.   }
  1170.   
  1171. ! static
  1172. ! int    LargerStr (S1, S2)
  1173. !    register char    * S1, * S2;
  1174. !    /* returns TRUE if S1 > S2 */
  1175.   {
  1176. !    while (*S1 == *S2 && *S1 != '\0' && *S2 != '\0') { S1++; S2++; }
  1177.   
  1178. !    return (*S1 > *S2);
  1179. ! }
  1180. ! 
  1181. ! static
  1182. ! DspList * DirListing (Path, Extension, Entries)
  1183. !    char    * Path, * Extension;
  1184. !    int    * Entries;
  1185. ! {
  1186. !    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  1187. !    DIR            * dirp;
  1188. !    struct direct    * d;
  1189. !    int            len, ext_len, count = 0;
  1190. !    char            ext[MAXPATHLENGTH];
  1191. ! 
  1192. !    if (*Path == '\0')
  1193.      {
  1194. !       if ((dirp = opendir (".")) == NULL) return (NULL);
  1195. !    }
  1196. !    else
  1197. !    {
  1198. !       if ((dirp = opendir (Path)) == NULL) return (NULL);
  1199. !    }
  1200.   
  1201. !    strcpy (ext, ".");
  1202. !    strcat (ext, Extension);
  1203. !    ext_len = strlen (ext);
  1204. !    head_ptr = tail_ptr = NULL;
  1205. ! 
  1206. !    while ((d = readdir (dirp)) != NULL)
  1207. !    {
  1208. !       len = strlen (d->d_name);
  1209. !       if (len > ext_len && (strcmp (ext, &d->d_name[len-ext_len]) == 0))
  1210. !       {
  1211. !          d->d_name[len-ext_len] = '\0';
  1212. !          dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  1213. !          strcpy (dsp_ptr->itemstr, d->d_name);
  1214. !          if (head_ptr == NULL)
  1215. !             head_ptr = tail_ptr = dsp_ptr;
  1216. !          else
  1217. !          {
  1218. !             p1 = NULL;
  1219. !             for (p = head_ptr; p != NULL; p = p->next)
  1220. !                if (LargerStr (d->d_name, p->itemstr))
  1221. !                   p1 = p;
  1222. !                else
  1223. !                   break;
  1224. ! 
  1225. !             dsp_ptr->next = p;
  1226. !             if (p == NULL)
  1227. !             {  /* dsp_ptr has the largest element */
  1228. !                tail_ptr->next = dsp_ptr;
  1229. !                tail_ptr = dsp_ptr;
  1230. !             }
  1231. !             else if (p1 == NULL)
  1232. !                head_ptr = dsp_ptr;
  1233. !             else
  1234. !                p1->next = dsp_ptr;
  1235. !          }
  1236. !          count++;
  1237. !       }
  1238.      }
  1239. ! 
  1240. !    closedir (dirp);
  1241. !    *Entries = count;
  1242. !    return (head_ptr);
  1243.   }
  1244.   
  1245. ! int SelectFileName (Extension, Str, SelStr)
  1246. !    char    * Extension, * Str, * SelStr;
  1247.   {
  1248. !    register int    i, index;
  1249. !    char        s[MAXPATHLENGTH], full_name[MAXPATHLENGTH];
  1250.      DspList    * dsp_ptr;
  1251.   
  1252. !    sprintf (s, "Generating list of file names, please wait ...");
  1253.      Msg (s);
  1254. -    strcpy (full_name, curDomainName);
  1255.   
  1256. !    if ((dsp_ptr = DirListing (curDomainName, Extension, &nameEntries)) == NULL)
  1257. !    {
  1258. !       strcpy (s, "No appropriate files to select from.");
  1259. !       Msg (s);
  1260. !       *SelStr = '\0';
  1261. !       return (INVALID);
  1262. !    }
  1263.   
  1264. !    nameDspPtr = MakeNameDspItemArray (nameEntries, dsp_ptr);
  1265.      nameFirst = 0;
  1266.      nameMarked = 0;
  1267.   
  1268. !    if ((index = Names (Str)) == INVALID)
  1269. !       *SelStr = '\0';
  1270.      else
  1271. !       strcpy (SelStr, nameDspPtr[index]);
  1272. ! 
  1273. !    for ( ; dsp_ptr != NULL; dsp_ptr = dsp_ptr->next) cfree (dsp_ptr);
  1274. !    cfree (nameDspPtr[0]);
  1275.      cfree (nameDspPtr);
  1276.   
  1277. !    s[0] = '\0';
  1278. !    Msg (s);
  1279. ! 
  1280.      return (index);
  1281.   }
  1282.   
  1283.   static
  1284. ! DspList * DomainListing (Path, Entries)
  1285. !    char    * Path;
  1286.      int    * Entries;
  1287.   {
  1288. !    DspList        * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  1289. !    DIR            * dirp, * dp;
  1290. !    struct direct    * d;
  1291. !    struct stat        stat_buf;
  1292. !    int            count = 0;
  1293. !    char            path[255], s[255];
  1294.   
  1295. !    if (*Path == '\0')
  1296. !       strcpy (path, ".");
  1297. !    else
  1298. !       strcpy (path, Path);
  1299.   
  1300. !    if ((dirp = opendir (path)) == NULL) return (NULL);
  1301.   
  1302. -    strcat (path, "/");
  1303.      head_ptr = tail_ptr = NULL;
  1304. ! 
  1305. !    while ((d = readdir (dirp)) != NULL)
  1306.      {
  1307. !       strcpy (s, path);
  1308. !       strcat (s, d->d_name);
  1309. ! 
  1310. !       stat (s, &stat_buf);
  1311. !       if (stat_buf.st_mode & S_IFDIR)
  1312.         {
  1313. !          dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  1314. !          strcpy (dsp_ptr->itemstr, d->d_name);
  1315. !          if (head_ptr == NULL)
  1316. !             head_ptr = tail_ptr = dsp_ptr;
  1317. !          else
  1318. !          {
  1319. !             p1 = NULL;
  1320. !             for (p = head_ptr; p != NULL; p = p->next)
  1321. !                if (LargerStr (d->d_name, p->itemstr))
  1322. !                   p1 = p;
  1323. !                else
  1324. !                   break;
  1325.   
  1326. !             dsp_ptr->next = p;
  1327. !             if (p == NULL)
  1328. !             {  /* dsp_ptr has the largest element */
  1329. !                tail_ptr->next = dsp_ptr;
  1330. !                tail_ptr = dsp_ptr;
  1331. !             }
  1332. !             else if (p1 == NULL)
  1333. !                head_ptr = dsp_ptr;
  1334.               else
  1335. !                p1->next = dsp_ptr;
  1336.            }
  1337. !          count++;
  1338.         }
  1339.      }
  1340. - 
  1341. -    closedir (dirp);
  1342. -    *Entries = count;
  1343.      return (head_ptr);
  1344.   }
  1345. --- 1274,1406 ----
  1346.   }
  1347.   
  1348. ! int SelectFileName (MsgStr, SelStr)
  1349. !    char    * MsgStr, * SelStr;
  1350.   {
  1351. !    int        index = INVALID, saved_num_dir_entries;
  1352. !    DspList    * dsp_ptr;
  1353.   
  1354. !    saved_num_dir_entries = numDirEntries;
  1355. !    if ((index = DirNames (MsgStr, SelStr)) == INVALID)
  1356.      {
  1357. !       numDirEntries = saved_num_dir_entries;
  1358. !       dsp_ptr = topOfDirLinkList;
  1359. !       for ( ; dsp_ptr != NULL; dsp_ptr = dsp_ptr->next) cfree (dsp_ptr);
  1360. !       topOfDirLinkList = NULL;
  1361.   
  1362. !       *SelStr = '\0';
  1363. !       return (INVALID);
  1364.      }
  1365. !    BuildDirList ();
  1366. !    Msg ("");
  1367. !    return (index);
  1368.   }
  1369.   
  1370. ! int SelectSymbolName (SelSymName, PathName)
  1371. !    char    * SelSymName, * PathName;
  1372.   {
  1373. !    register int    i, index = INVALID;
  1374. !    char        s[MAXPATHLENGTH], msg[MAXSTRING];
  1375.      DspList    * dsp_ptr;
  1376.   
  1377. !    sprintf (s,
  1378. !          "Generating a list of symbol names in '%s' domain, please wait ...",
  1379. !          curDomainName);
  1380.      Msg (s);
  1381.   
  1382. ! /* if ((topOfSymLinkList = SymbolListing ()) == NULL) */
  1383. ! /* { */
  1384. ! /*    Msg ("No symbol found!"); */
  1385. ! /*    SelSymName[0] = '\0'; */
  1386. ! /*    PathName[0] = '\0'; */
  1387. ! /*    return (INVALID); */
  1388. ! /* } */
  1389. ! /* BuildSymbolList (); */
  1390.   
  1391. !    nameEntries = numSymbols;
  1392. !    nameDspPtr = MakeNameDspItemArray (nameEntries, symbolList);
  1393.      nameFirst = 0;
  1394.      nameMarked = 0;
  1395.   
  1396. !    sprintf (msg, "Please select a symbol to INSTANTIATE in the '%s' domain ...",
  1397. !          curDomainName);
  1398. !    if ((index = ChooseAName (msg, SelSymName)) == INVALID)
  1399. !    {
  1400. !       *SelSymName = '\0';
  1401. !       *PathName = '\0';
  1402. !    }
  1403.      else
  1404. !    {
  1405. !       strcpy (SelSymName, nameDspPtr[index]);
  1406. !       strcpy (PathName, symbolList[index].pathstr);
  1407. !    }
  1408. !    cfree (*nameDspPtr);
  1409.      cfree (nameDspPtr);
  1410.   
  1411. !    Msg ("");
  1412.      return (index);
  1413.   }
  1414.   
  1415. + int GetSymbolPath (SymName, PathName)
  1416. +    char    * SymName, * PathName;
  1417. + {
  1418. +    register int    i;
  1419. + 
  1420. +    for (i = 0; i < numSymbols; i++)
  1421. +       if (strcmp (SymName, symbolList[i].itemstr) == 0)
  1422. +       {
  1423. +          strcpy (PathName, symbolList[i].pathstr);
  1424. +          return (TRUE);
  1425. +       }
  1426. +    return (FALSE);
  1427. + }
  1428. + 
  1429.   static
  1430. ! DspList * DomainListing (Entries)
  1431.      int    * Entries;
  1432.   {
  1433. !    register int    i, default_index = 0;
  1434. !    char        s[MAXSTRING], * c_ptr;
  1435. !    DspList    * dsp_ptr = NULL, * head_ptr, * tail_ptr, * p, * p1;
  1436.   
  1437. !    if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, "MaxDomains")) == NULL)
  1438. !       return (NULL);
  1439.   
  1440. !    *Entries = atoi (c_ptr);
  1441.   
  1442.      head_ptr = tail_ptr = NULL;
  1443. !    for (i = 0; i < *Entries; i++)
  1444.      {
  1445. !       sprintf (s, "Domain%1d", i);
  1446. !       if ((c_ptr = XGetDefault (mainDisplay, TOOL_NAME, s)) == NULL)
  1447.         {
  1448. !          for ( ; head_ptr != NULL; head_ptr = head_ptr->next) cfree (head_ptr);
  1449. !          return (NULL);
  1450. !       }
  1451.   
  1452. !       dsp_ptr = (DspList *) calloc (1, sizeof(DspList));
  1453. !       strcpy (dsp_ptr->itemstr, c_ptr);
  1454. !       if (head_ptr == NULL)
  1455. !          head_ptr = tail_ptr = dsp_ptr;
  1456. !       else
  1457. !       {
  1458. !          p1 = NULL;
  1459. !          for (p = head_ptr; p != NULL; p = p->next)
  1460. !             if (LargerStr (dsp_ptr->itemstr, p->itemstr))
  1461. !                p1 = p;
  1462.               else
  1463. !                break;
  1464. ! 
  1465. !          dsp_ptr->next = p;
  1466. !          if (p == NULL)
  1467. !          {  /* dsp_ptr has the largest element */
  1468. !             tail_ptr->next = dsp_ptr;
  1469. !             tail_ptr = dsp_ptr;
  1470.            }
  1471. !          else if (p1 == NULL)
  1472. !             head_ptr = dsp_ptr;
  1473. !          else
  1474. !             p1->next = dsp_ptr;
  1475.         }
  1476.      }
  1477.      return (head_ptr);
  1478.   }
  1479. ***************
  1480. *** 701,712 ****
  1481.      char    * SelStr;
  1482.   {
  1483. !    register int        i, index;
  1484. !    char            s[MAXPATHLENGTH];
  1485. !    DspList        * dsp_ptr;
  1486.   
  1487.      Msg ("Generating list of domain names, please wait ...");
  1488.   
  1489. !    if ((dsp_ptr = DomainListing (curDomainName, &nameEntries)) == NULL)
  1490.      {
  1491.         *SelStr = '\0';
  1492.         return (INVALID);
  1493. --- 1409,1421 ----
  1494.      char    * SelStr;
  1495.   {
  1496. !    int        index;
  1497. !    char        s[MAXPATHLENGTH];
  1498. !    DspList    * dsp_ptr;
  1499.   
  1500.      Msg ("Generating list of domain names, please wait ...");
  1501.   
  1502. !    if ((dsp_ptr = DomainListing (&nameEntries)) == NULL)
  1503.      {
  1504. +       Msg ("No domain names found.");
  1505.         *SelStr = '\0';
  1506.         return (INVALID);
  1507. ***************
  1508. *** 717,721 ****
  1509.      nameMarked = 0;
  1510.   
  1511. !    if ((index = Names ("PLEASE SELECT NEW DOMAIN ...")) == INVALID)
  1512.         *SelStr = '\0';
  1513.      else
  1514. --- 1426,1430 ----
  1515.      nameMarked = 0;
  1516.   
  1517. !    if ((index = ChooseAName ("Please select a new DOMAIN ...", "")) == INVALID)
  1518.         *SelStr = '\0';
  1519.      else
  1520. ***************
  1521. *** 730,732 ****
  1522. --- 1439,1465 ----
  1523.   
  1524.      return (index);
  1525. + }
  1526. + 
  1527. + void SetCurDir (FileName)
  1528. +    char    * FileName;
  1529. + {
  1530. +    register int    i;
  1531. +    char        file_name[MAXPATHLENGTH];
  1532. + 
  1533. +    if (*FileName != '/')
  1534. +       strcpy (file_name, bootDir);
  1535. +    else
  1536. +       strcpy (file_name, FileName);
  1537. + 
  1538. +    for (i = strlen(file_name)-1; i>=0 && file_name[i]!='/'; i--) ;
  1539. + 
  1540. +    if (i < 0)
  1541. +       TwoLineMsg ("Error:  No '/' found in SetCurDir ().",
  1542. +                   "        curDir and curFileName not set.");
  1543. +    else
  1544. +    {
  1545. +       strcpy (curFileName, &file_name[i+1]);
  1546. +       file_name[i] = '\0';
  1547. +       strcpy (curDir, file_name);
  1548. +    }
  1549.   }
  1550. ---------------------------------> cut here <---------------------------------
  1551. -- 
  1552. Bill Cheng // UCLA Computer Science Department // (213) 206-7135
  1553. 3277 Boelter Hall // Los Angeles, California 90024 // USA
  1554. william@CS.UCLA.EDU      ...!{uunet|ucbvax}!cs.ucla.edu!william
  1555.  
  1556. dan
  1557. ----------------------------------------------------
  1558. O'Reilly && Associates   argv@sun.com / argv@ora.com
  1559. Opinions expressed reflect those of the author only.
  1560. --
  1561. dan
  1562. ----------------------------------------------------
  1563. O'Reilly && Associates   argv@sun.com / argv@ora.com
  1564. Opinions expressed reflect those of the author only.
  1565.